﻿using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;

namespace _42_Kicks
{


    public class Heros : AniSprite
    {
        //Ce rect servira à dessiner le personnage en saut 
        public Vector2 jump;


        public int t1 = 0;
        //Pour les collisions
        public int decalageX;
        public int decalageY;
        public int largeur;
        public int hauteur;

        public int pointdevie = 200;
        //Ces booléens servirons non pas à déclencher les fonctions de marche, saut... mais des effets lors de collisions, des coups ce genre de choses
        public bool marche;
        public bool saute;
        public bool pirouette;
        public bool deplat = true;
        bool cantbetouched = false;


        //Constructeurs de la classe Heros ne rien modifier ici
        public Heros(Vector2 position, Rectangle source)
            : base(position, source)
        { }
        public Heros(float posx, float posy, int x, int y, int width, int height)
            : base(posx, posy, x, y, width, height)
        { }
        public Heros(Texture2D texture)
            : base(texture)
        { }

        public override void LoadContent(ContentManager content, string assetName)
        {
            texture = content.Load<Texture2D>(assetName);
            jump = position;
        }

        //Cette putain de fonction sert à définir la hitbox t'entends ??? Vu qu'on peut monter descendre la rue 
        //la hitbox du perso est un mini rect à raz du sol
        public virtual void SetRect()
        {
            if (marche == true && saute == false && pirouette == false)
            { decalageX = 51; largeur = 52; decalageY = 109; hauteur = 42; }
            if (marche == false && saute == false && pirouette == false)
            { decalageX = 42; largeur = 57; decalageY = 109; hauteur = 42; }
            if (marche == false && saute == false && false && pirouette == false)
            { decalageX = 51; largeur = 57; decalageY = 109; hauteur = 42; }
            if (marche == false && saute == true && false && pirouette == false)
            { decalageX = 51; largeur = 57; decalageY = 109; hauteur = 42; }
            if (marche == false && saute == true && false && pirouette == true)
            { decalageX = 30; largeur = 98; decalageY = 109; hauteur = 42; }
        }



        /*Fonction de collision, on s'en servira simplement pour déterminer s'il y a collision, mais en aucun cas elle ne génère d'effets aurtes que la détection */
        public virtual bool Collision(Rectangle colli)
        {



            Rectangle herosPos = new Rectangle((int)position.X + decalageX, (int)position.Y + decalageY,
                                    largeur, hauteur);

            return herosPos.Intersects(colli);


        }

        // Ceci est la fonction de marche, à déclencher pour permettre au personnage de marcher





        public virtual void Marche(GameTime gameTime)
        {

            KeyboardState KState = Keyboard.GetState();
            if (KState.IsKeyDown(Keys.Right) || KState.IsKeyDown(Keys.Left) || KState.IsKeyDown(Keys.Up) || KState.IsKeyDown(Keys.Down))
            { marche = true; }
            else { marche = false; }


            if (KState.IsKeyDown(Keys.Left) && marche == true && saute == false)
            {
                position += (new Vector2(-1 * gameTime.ElapsedGameTime.Milliseconds * 0.25f, 0));
                DefileSpriteGauche(3306, 3910, 151, 151, 151, gameTime);
            }
            if (KState.IsKeyDown(Keys.Left) && marche == true && saute == true)
            {

                position += (new Vector2(-1 * gameTime.ElapsedGameTime.Milliseconds * 0.33f, 0));
                DefileSpriteGauche(3306, 3910, 151, 151, 151, gameTime);
            }


            if (KState.IsKeyDown(Keys.Right) && marche == true && saute == false)
            {
                position += (new Vector2(1 * gameTime.ElapsedGameTime.Milliseconds * 0.25f, 0));
                DefileSprite(0, 604, 0, 151, 151, gameTime);
                decalageX = 51;
            }
            if (KState.IsKeyDown(Keys.Right) && marche == true && saute == true)
            {
                position += (new Vector2(1 * gameTime.ElapsedGameTime.Milliseconds * 0.33f, 0));
                DefileSprite(0, 604, 0, 151, 151, gameTime);
            }

            if (KState.IsKeyDown(Keys.Up) && marche == true && saute == false)
            {


                position += (new Vector2(0, -1 * gameTime.ElapsedGameTime.Milliseconds * 0.16f));
                if (source.Y == 0)
                    DefileSprite(0, 604, 0, 151, 151, gameTime);
                if (source.Y == 151)
                    DefileSpriteGauche(3306, 3910, 151, 151, 151, gameTime);
            }
            if (KState.IsKeyDown(Keys.Down) && marche == true && saute == false)
            {


                position += (new Vector2(0, 1 * gameTime.ElapsedGameTime.Milliseconds * 0.16f));
                if (source.Y == 0)
                    DefileSprite(0, 604, 0, 151, 151, gameTime);
                if (source.Y == 151)
                    DefileSpriteGauche(3306, 3910, 151, 151, 151, gameTime);
            }
        }





        //Cette fonction définit l'état d'arrêt et permet entre autres d'avoir des animations cohérentes

        public virtual void Arret(GameTime gameTime)
        {
            KeyboardState KState = Keyboard.GetState();

            if (marche == false && pirouette == false && saute == false)
            {
                if (KState.IsKeyUp(Keys.Down) && source.Y == 0 || source.Y == 302)
                {
                    source.X = 604;
                    source.Y = 0;
                }
                if (KState.IsKeyUp(Keys.Down) && source.Y == 151 || source.Y == 453)
                {
                    source.X = 3306;
                    source.Y = 151;
                }
            }
        }



        // Ceci est la fonction de saut
        public virtual void Saute(GameTime gameTime)
        {

            if (t1 <= 487 && t1 >= 136)
            { cantbetouched = true; }
            else { cantbetouched = false; }
                
            KeyboardState KState = Keyboard.GetState();
            jump.X = position.X;
            if (saute == false) { jump.Y = position.Y; }
            if (t1 == 0 && KState.IsKeyDown(Keys.Space))
            {
                jump.Y = position.Y;
            }

            if (KState.IsKeyDown(Keys.Space) && t1 <= 0)
            {
                saute = true;
                t1 = 731;
            }

            if (saute == true && t1 > 380)


                jump.Y += -1.8f * gameTime.ElapsedGameTime.Milliseconds * 0.25f;
            t1 -= gameTime.ElapsedGameTime.Milliseconds;
            if (saute == true && t1 < 380)
                jump.Y += 1.8f * gameTime.ElapsedGameTime.Milliseconds * 0.25f;


            //Permet d'avoir l'animation de saut "normale" si on ne se déplace pas au lieu de la pirouette ninja
            if (source.Y == 0 && saute == true && t1 > 680 || pirouette == false && saute == true && source.Y == 302)
            {


                source.X = 3624;
                source.Y = 0;
            }
            if (source.Y == 151 && saute == true && t1 > 680 || pirouette == false && saute == true && source.Y == 453)
            {


                source.X = 286;
                source.Y = 151;
            }
            //Permet d'avoir les animations de la pirouette ninja et le booléen pirouette

            if (source.Y == 0 && saute == true && t1 < 680)
            {

                if (KState.IsKeyDown(Keys.Right))
                {
                    pirouette = true;
                    DefileSprite(0, 1208, 302, 94, 151, gameTime);
                }

            }
            else pirouette = false;

            if (source.Y == 151 && saute == true && t1 < 680)
            {

                if (KState.IsKeyDown(Keys.Left))
                {
                    pirouette = true;
                    DefileSpriteGauche(2711, 3919, 453, 94, 151, gameTime);
                }
                else pirouette = false;
            }

            //Permet de retomber


            if (t1 <= 0)

                saute = false;



        }



        public override void Draw(SpriteBatch spriteBatch, Color colour)
        {
            if (saute == false)
                spriteBatch.Draw(texture, position, source, colour);
            else

                spriteBatch.Draw(texture, jump /*Jump c le rectangle pour dessiner le personnage en saut*/, source, colour);
        }

    }

}





